#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//#include "FuncionesPPD.h"
#include <sys/types.h>
#include <sys/socket.h>

#include "protocolo1.h"


/*Funcion para pasar de integer a string, recibe el valor y la base del mismo*/


char* itoa(int val, int base)
{
	static char buf[32] = {0};
	int i = 30;

	for(; val && i ; --i, val /= base)

		buf[i] = "0123456789abcdef"[val % base];

	return &buf[i+1];
}


/*Compacta el mensaje*/

char *NIPC_Serialize(NIPC *nipc)
{
	char *result = malloc(sizeof(struct nodoNIPC));
	char *auxType;
	char *auxPayloadLength;
	int i = 0;

	auxPayloadLength = malloc(4);

	strcpy(auxPayloadLength,itoa(nipc->payloadLength,10));
	for(i=strlen(auxPayloadLength);i<=4;i++) strcat(auxPayloadLength,"\0");

	strcpy(result,"");
	//auxType = itoa(nipc->type,10);
	//strcat(result,auxType);
	strcat(result,&nipc->type);
	strcat(result,"-");
	strcat(result,auxPayloadLength);
	strcat(result,"-");
	strcat(result,nipc->payload);
	strcat(result,"-");
//	free(auxPayloadLength);
	return result;
}

/*Descompacta el mensaje*/

NIPC *NIPC_Unserialize(char *message){
	NIPC *nipc;
	char *auxUnserialize;
	char *auxType;
	char *auxPayloadLength;
	char *payload;
//	int offset = 0;

	auxType = malloc( strlen("a") );
	auxPayloadLength = malloc(strlen("aa") ) ;
	payload = (char *)malloc(sizeof(message - 3));
//	nipc = (struct nodoNIPC *)malloc(sizeof(struct nodoNIPC));

	strncpy(auxType,message,strpos(message,'-'));
	//offset += 1;
	strncpy(auxUnserialize,&message[strpos(message,'-') + 1], (strlen(message) - strpos(message,'-') - 1 ));
	auxUnserialize[600]='\0';
	strncpy(auxPayloadLength,auxUnserialize, strpos(auxUnserialize,'-') );
	//offset += 4;
	strncpy(auxUnserialize,&auxUnserialize[strpos(auxUnserialize,'-') +1 ], strlen(auxUnserialize) - strpos(auxUnserialize,'-')-1 );
	strncpy(payload,auxUnserialize,strlen(auxUnserialize)- strpos(auxUnserialize,'-') -1);

	nipc = (struct nodoNIPC *)malloc(sizeof(message)-3);

	strcpy(&nipc->type,auxType);
	nipc->payloadLength = atoi(auxPayloadLength);
	nipc->payload = payload;

	free(auxType);
	free(auxPayloadLength);
	free(payload);

	return nipc;
}


int32_t handshakePPD_RAID (int32_t sock , char* mensaje){
		char *paqueteSend;
		char *paqueteReciv;
		NIPC *paquete;
		paqueteReciv=malloc(sizeof(struct nodoNIPC));
		paquete = (struct nodoNIPC *) malloc(sizeof(struct nodoNIPC));
		paquete->type= 0;
		paquete->payloadLength= strlen(mensaje);
		paquete->payload= mensaje;
		paqueteSend= NIPC_Serialize(paquete);
		send(sock, paqueteSend,strlen(paqueteSend),MSG_CONFIRM);
		//recv(sock, paqueteReciv, 600 ,MSG_CONFIRM);
		paquete=NIPC_Unserialize(paqueteSend);
		printf("%s "  "%i " "%s ", paquete->type,paquete->payloadLength,paquete->payload);
		if (paquete->payloadLength == 0){
			free(paquete);
			free(paqueteReciv);
			//free(paqueteSend);
			return -1;
		}
		free(paquete);
		free(paqueteReciv);
		//free(paqueteSend);
	return 1;
}

int32_t handshakePPD_FS (int32_t sock ){
		char *paqueteSend;
		char *paqueteReciv;
		NIPC *paquete;
		recv(sock, paqueteReciv, 600 ,MSG_CONFIRM);
		paquete=NIPC_Unserialize(paqueteReciv);
		if (paquete->type == "0"){


		}


	return 1;
}





/*Funcion auxiliar para pruebas*/
/*
int main (void){

	char *serializado;
	NIPC *sinSerializar;
	NIPC *mensaje;

	sinSerializar = (struct nodoNIPC *)malloc(sizeof(struct nodoNIPC));
	mensaje = (struct nodoNIPC *)malloc(sizeof(struct nodoNIPC));

	mensaje->type = 1;
	mensaje->payloadLength = 512;
	mensaje->payload = "hola mundo";

	serializado = NIPC_Serialize(mensaje);
	sinSerializar = NIPC_Unserialize(serializado);

	free(sinSerializar);
	free(mensaje);

	return 1;
}
*/
